/**
 * 优惠券控制器
 */
const { Coupon, User, Order, sequelize } = require('../models');
const { Op } = require('sequelize');
const { generateOrderNumber } = require('../utils/orderUtils');
const { verify } = require('jsonwebtoken');

// 获取所有可用优惠券
exports.getAllCoupons = async (req, res) => {
  try {
    const coupons = await Coupon.findAll({
      where: {
        isTemplate: true,         // 只查模板券
        status: 1,                // 状态正常
        expireDate: {
          [Op.gte]: new Date()    // 未过期
        },
        [Op.or]: [
          { stock: -1 },          // 不限库存
          { stock: { [Op.gt]: 0 } } // 有库存
        ]
      },
      order: [['id', 'DESC']]     // 按ID降序排列，最新的排在前面
    });
    for (let coupon of coupons) {
      if(coupon.roomType == 0){
        coupon.roomType = '小包';
      } else if(coupon.roomType == 1){
        coupon.roomType = '中包';
      } else if(coupon.roomType == 2){
        coupon.roomType = '大包';
      } else if(coupon.roomType == 3){
        coupon.roomType = '豪华包';
      }
    }
    return res.status(200).json({
      success: true,
      data: coupons
    });
  } catch (error) {
    console.error('获取优惠券列表失败:', error);
    return res.status(500).json({
      success: false,
      message: '获取优惠券列表失败',
      error: error.message
    });
  }
};

// 获取优惠券详情
exports.getCouponById = async (req, res) => {
  try {
    const { id } = req.params;
    
    const coupon = await Coupon.findOne({
      where: {
        id,
        isTemplate: true // 只查询模板券
      }
    });
    
    if (!coupon) {
      return res.status(404).json({
        success: false,
        message: '优惠券不存在'
      });
    }
    
    return res.status(200).json({
      success: true,
      data: coupon
    });
  } catch (error) {
    console.error('获取优惠券详情失败:', error);
    return res.status(500).json({
      success: false,
      message: '获取优惠券详情失败',
      error: error.message
    });
  }
};

// 购买优惠券
exports.purchaseCoupon = async (req, res) => {
  try {
    const { couponId } = req.params;
    const userId = req.user.id; // 假设用户信息在认证中间件中被设置
    
    console.log(`[优惠券购买] 用户${userId}尝试购买优惠券${couponId}`);
    
    // 查找模板优惠券
    const templateCoupon = await Coupon.findOne({
      where: {
        id: couponId,
        isTemplate: true,
        status: 1
      }
    });
    
    if (!templateCoupon) {
      return res.status(404).json({
        success: false,
        message: '优惠券不存在'
      });
    }
    
    // 检查是否过期
    if (new Date(templateCoupon.expireDate) < new Date()) {
      return res.status(400).json({
        success: false,
        message: '优惠券已过期'
      });
    }
    
    // 检查库存
    if (templateCoupon.stock !== -1 && templateCoupon.stock <= 0) {
      return res.status(400).json({
        success: false,
        message: '优惠券库存不足'
      });
    }
    
    // 创建订单，然后重定向到支付页面
    const orderId = `CPN_${Date.now()}_${Math.floor(Math.random() * 1000)}`;
    const orderNo = generateOrderNumber('CP');
    
    // 创建订单
    const order = await Order.create({
      id: orderId,
      order_no: orderNo,
      user_id: userId,
      order_type: 'recharge', // 使用充值类型而不是优惠券类型
      amount: templateCoupon.price,
      status: 'pending',
      create_time: new Date(),
      remark: `购买优惠券: ${templateCoupon.title} (ID: ${couponId})`,
    });
    
    console.log(`[优惠券购买] 创建订单成功: ${orderId}`);
    
    // 生成支付链接
    const paymentUrl = `/pages/payment/payment?type=coupon&id=${orderId}&amount=${templateCoupon.price}&title=${encodeURIComponent(templateCoupon.title)}`;
    
    // 返回支付URL
    return res.status(200).json({
      success: true,
      message: '请前往支付页面完成支付',
      data: {
        orderId,
        couponId,
        amount: templateCoupon.price,
        payment_url: paymentUrl
      }
    });
  } catch (error) {
    console.error('创建优惠券订单失败:', error);
    return res.status(500).json({
      success: false,
      message: '创建订单失败，请稍后重试',
      error: error.message
    });
  }
};

// 处理优惠券支付成功
exports.handleCouponPayment = async (req, res) => {
  const transaction = await sequelize.transaction();
  
  try {
    const { orderId } = req.params;
    const userId = req.user.id;
    
    console.log(`[支付处理] 处理优惠券订单支付: ${orderId}, 用户ID: ${userId}`);
    
    // 查找并验证订单
    const order = await Order.findOne({
      where: {
        id: orderId,
        user_id: userId,
        order_type: 'recharge', // 使用充值类型而不是优惠券类型
        status: 'pending' // 只能处理待支付订单
      },
      transaction
    });
    
    if (!order) {
      await transaction.rollback();
      return res.status(404).json({
        success: false,
        message: '订单不存在或已处理'
      });
    }
    
    // 更新订单状态
    await order.update({
      status: 'paid',
      payment_method: 'wechat', // 假设使用微信支付
      payment_time: new Date(),
      update_time: new Date()
    }, { transaction });
    
    // 从订单描述中提取优惠券ID
    const couponIdMatch = order.remark.match(/购买优惠券: .* \(ID: (\d+)\)/);
    let couponId;
    
    if (couponIdMatch && couponIdMatch[1]) {
      couponId = couponIdMatch[1];
    } else {
      // 如果没有匹配到，尝试从请求中获取
      couponId = req.body.couponId;
      
      // 如果请求中也没有couponId，则从备注中尝试提取数字
      if (!couponId) {
        const numberMatch = order.remark.match(/\d+/);
        if (numberMatch) {
          couponId = numberMatch[0];
        }
      }
    }
    
    if (!couponId) {
      await transaction.rollback();
      return res.status(400).json({
        success: false,
        message: '缺少优惠券ID信息'
      });
    }
    
    // 查找模板优惠券
    const templateCoupon = await Coupon.findOne({
      where: {
        id: couponId,
        isTemplate: true,
        status: 1
      },
      transaction
    });
    
    if (!templateCoupon) {
      await transaction.rollback();
      return res.status(404).json({
        success: false,
        message: '优惠券不存在'
      });
    }
    
    // 更新库存
    if (templateCoupon.stock !== -1) {
      await templateCoupon.update({
        stock: templateCoupon.stock - 1
      }, { transaction });
    }
    //随机生成6位数字作为劵码
    verifyCode = Math.floor(100000 + Math.random() * 900000).toString();
    // 创建用户优惠券记录
    const userCoupon = await Coupon.create({
      title: templateCoupon.title,
      price: templateCoupon.price,
      duration: templateCoupon.duration,
      expireDate: templateCoupon.expireDate,
      terms: templateCoupon.terms,
      periodLimit: templateCoupon.periodLimit,
      isTemplate: false, // 标记为用户实例券
      userId,
      remainTimes: 1,
      status: 1, // 未使用状态
      templateId: templateCoupon.id,
      purchaseTime: new Date(),
      verifyCode: verifyCode, // 初始化为空
      roomType: templateCoupon.roomType, // 复制房间类型
    }, { transaction });
    
    await transaction.commit();
    
    return res.status(200).json({
      success: true,
      message: '支付成功，优惠券已添加到您的账户',
      data: userCoupon
    });
  } catch (error) {
    await transaction.rollback();
    console.error('处理优惠券支付失败:', error);
    return res.status(500).json({
      success: false,
      message: '处理支付失败，请联系客服',
      error: error.message
    });
  }
};

// 获取用户的优惠券列表
exports.getUserCoupons = async (req, res) => {
  try {
    const userId = req.user.id; // 假设用户信息在认证中间件中被设置
    
    const userCoupons = await Coupon.findAll({
      where: {
        userId,
        isTemplate: false,
        // status: 1 // 未使用状态
      },
      include: [{
        model: Coupon,
        as: 'template', 
        attributes: ['title', 'periodLimit', 'price', 'purchase_time','status']
      }],
      order: [['purchaseTime', 'DESC']]
    });
    for (let coupon of userCoupons) {
      // 如果优惠券已过期，将状态改为已过期
      const expireDate = new Date(coupon.expireDate);
      const currentDate = new Date();
      if (expireDate < currentDate) {
        coupon.status = 2; // 已过期
        await coupon.save();
      }
      if(coupon.roomType == 0){
        coupon.roomType = '小包';
      } else if(coupon.roomType == 1){
        coupon.roomType = '中包';
      } else if(coupon.roomType == 2){
        coupon.roomType = '大包';
      } else if(coupon.roomType == 3){
        coupon.roomType = '豪华包';
      }
    }
    return res.status(200).json({
      success: true,
      data: userCoupons
    });
  } catch (error) {
    console.error('获取用户优惠券列表失败:', error);
    return res.status(500).json({
      success: false,
      message: '获取用户优惠券列表失败',
      error: error.message
    });
  }
};

// 获取优惠券中心列表
exports.getCouponCenter = async (req, res) => {
  try {
    const { page = 1, limit = 10 } = req.query;
    
    const { count, rows } = await Coupon.findAndCountAll({
      where: {
        isTemplate: true,
        status: 1,
        expireDate: {
          [Op.gte]: new Date()
        }
      },
      limit: parseInt(limit),
      offset: (parseInt(page) - 1) * parseInt(limit),
      order: [['id', 'DESC']]
    });
    
    res.status(200).json({
      code: 200,
      message: '获取优惠券中心列表成功',
      data: {
        total: count,
        items: rows,
        page: parseInt(page),
        limit: parseInt(limit)
      }
    });
  } catch (error) {
    console.error('获取优惠券中心列表失败:', error);
    res.status(500).json({
      code: 500,
      message: '获取优惠券中心列表失败，请稍后重试',
      data: null
    });
  }
};

// 领取免费优惠券
exports.claimCoupon = async (req, res) => {
  const transaction = await sequelize.transaction();
  
  try {
    const userId = req.user.id;
    const { couponId } = req.body;
    
    // 查询模板券
    const templateCoupon = await Coupon.findOne({
      where: {
        id: couponId,
        isTemplate: true,
        status: 1,
        price: 0, // 只能领取免费券
        expireDate: { [Op.gte]: new Date() }
      },
      transaction
    });
    
    if (!templateCoupon) {
      await transaction.rollback();
      return res.status(404).json({
        code: 404,
        message: '优惠券不存在或不可领取',
        data: null
      });
    }
    
    // 检查库存
    if (templateCoupon.stock !== -1 && templateCoupon.stock <= 0) {
      await transaction.rollback();
      return res.status(400).json({
        code: 400,
        message: '优惠券库存不足',
        data: null
      });
    }
    
    // 检查用户是否已领取过
    const existingCoupon = await Coupon.findOne({
      where: {
        userId,
        templateId: couponId,
        isTemplate: false
      },
      transaction
    });
    
    if (existingCoupon) {
      await transaction.rollback();
      return res.status(400).json({
        code: 400,
        message: '您已领取过该优惠券',
        data: null
      });
    }
    
    // 更新库存
    if (templateCoupon.stock !== -1) {
      await templateCoupon.update({
        stock: templateCoupon.stock - 1
      }, { transaction });
    }
    
    // 创建用户优惠券
    const userCoupon = await Coupon.create({
      title: templateCoupon.title,
      price: 0,
      duration: templateCoupon.duration,
      expireDate: templateCoupon.expireDate,
      terms: templateCoupon.terms,
      periodLimit: templateCoupon.periodLimit,
      isTemplate: false,
      userId,
      remainTimes: 1,
      status: 1,
      templateId: templateCoupon.id,
      purchaseTime: new Date()
    }, { transaction });
    
    await transaction.commit();
    
    return res.status(200).json({
      code: 200,
      message: '领取优惠券成功',
      data: userCoupon
    });
  } catch (error) {
    await transaction.rollback();
    console.error('领取优惠券失败:', error);
    res.status(500).json({
      code: 500,
      message: '领取优惠券失败，请稍后重试',
      data: null
    });
  }
}; 

// 券码验证
exports.verifyCoupon = async (req, res) => {
  try {
    const userId = req.user.id;
    const { verifyCode } = req.body;
    const { id } = req.params;
    const coupon = await Coupon.findOne({
      where: {
        userId: userId,
        verifyCode: verifyCode,
        status: 1, // 未使用状态
        isTemplate: false // 只查询用户的优惠券
      }
    });
    
    if (!coupon) {
      return res.status(404).json({
        success: false,
        message: '优惠券验证失败'
      });
    } 
    return res.status(200).json({
      success: true,
      data: coupon
    });
  } catch (error) {
    console.error('优惠券验证错误:', error);
    return res.status(500).json({
      success: false,
      message: '优惠券验证错误',
      error: error.message
    });
  }
}; 


// 修改优惠券状态
exports.updateStatus = async (req, res) => {
  try {
    // 验证用户 ID 是否存在
    if (!req.user || !req.user.id) {
      return res.status(401).json({
        success: false,
        message: '用户未认证或缺少用户 ID'
      });
    }
    const userId = req.user.id;

    // 验证请求体是否存在
    if (!req.body) {
      return res.status(400).json({
        success: false,
        message: '请求体为空'
      });
    }

    const { couponId } = req.body;

    // 验证优惠券 ID 是否存在且为有效格式
    if (!couponId || isNaN(couponId)) {
      return res.status(200).json({
        success: true,
        message: '缺少有效的优惠券 ID'
      });
    }

    const coupon = await Coupon.findOne({
      where: {
        userId: userId,
        id: couponId,
        status: 1, // 未使用状态
        isTemplate: false // 只查询用户的优惠券
      }
    });

    if (!coupon) {
      return res.status(200).json({
        success: true,
        message: '优惠券不存在或已使用'
      });
    }

    // 更新优惠券状态为已使用
    coupon.status = 0; 
    await coupon.save();

    return res.status(200).json({
      success: true,
      data: coupon
    });
  } catch (error) {
    console.error('优惠券状态修改错误:', error);
    return res.status(500).json({
      success: false,
      message: '优惠券状态修改错误',
      error: error.message
    });
  }
};